CMD File

The linker allows file, section, and symbol names to be specified using the asterisk (*) and question mark (?) wild cards. Using * matches any number of characters and using ? matches a single character.

The C/C++ compiler uses an uninitialized section called .sysmem for the C run-time memory pool used by malloc(). You can set the size of this memory pool at link time by using the –heap_size option. The syntax for the –heap_size option is:

--heap_size= size

The size must be a constant. This example defines a 4K byte heap:

cl6x --run_linker --heap_size=0x1000 /* defines a 4k heap (.sysmem section)*/

The linker creates the .sysmem section only if there is a .sysmem section in an input file. The linker also creates a global symbol __SYSMEMSIZE and assigns it a value equal to the size of the heap. The default size is 1K bytes.

The TMS320C6000 C/C++ compiler uses an uninitialized section, .stack, to allocate space for the run-time stack. The syntax for the --stack_size option is:

--stack_size= size The size must be a constant and is in bytes. This example defines a 4K byte stack:

cl6x --run_linker --stack_size=0x1000 /* defines a 4K heap (.stack section)*/

When the linker defines the .stack section, it also defines a global symbol, __STACK_SIZE, and assigns it a value equal to the size of the section. The default software stack size is 1K bytes.

The linker determines where output sections are allocated into memory; it must have a model of target memory to accomplish this. The MEMORY directive allows you to specify a model of target memory so that you can define the types of memory your system contains and the address ranges they occupy.

After you use MEMORY to define a memory model, you can use the SECTIONS directive to allocate output sections into defined memory.

If you do not use the MEMORY and SECTIONS directives, the linker allocates output sections as though the definitions in Example were specified. Example Default Allocation for TMS320C6000 Devices

MEMORY
{
RAM : origin = 0x00000001, length = 0xFFFFFFFE
}
SECTIONS
{
.text : ALIGN(32) {} > RAM
.const : ALIGN(8) {} > RAM
.data : ALIGN(8) {} > RAM
.bss : ALIGN(8) {} > RAM
.cinit : ALIGN(4) {} > RAM ; cflag option only
.pinit : ALIGN(4) {} > RAM ; cflag option only
.stack : ALIGN(8) {} > RAM ; cflag option only
.far : ALIGN(8) {} > RAM ; cflag option only
.sysmem: ALIGN(8) {} > RAM ; cflag option only
.switch: ALIGN(4) {} > RAM ; cflag option only
.cio : ALIGN(4) {} > RAM ; cflag option only
}

C/C++ programs require initialization of the run-time environment before execution of the program itself may begin. This initialization is performed by a bootstrap routine. This routine is responsible for creating the stack, initializing global variables, and calling main(). The bootstrap routine should be the entry point for the program, and it typically should be the RESET interrupt handler. The bootstrap routine is responsible for the following tasks:

1. Set up the stack by initializing SP
2. Set up the data page pointer DP (for architectures that have one)
3. Set configuration registers
4. Process the .cinit table to autoinitialize global variables (when using the –rom_model option)
5. Process the .pinit table to construct global C++ objects.
6. Call main with appropriate arguments
7. Call exit when main returns

（1）被初始化的“SECTIONS”(包括数据表和可执行代码)

• .text 它包括所有的可执行代码和常数，必须放在程序页；
• .cinit 它包括初始化的变量和常量表,要求放在程序页；
• .pinit 它包括全局构造器(C++)初始化的变量和常量表，要求放在程序页；
• .const 它包括字符串、声明、以及被明确初始化过的全局和静态变量，要求放在低地址的数 据页；
• .econst 它是在使用大存储器模式时使用的，包括字符串、声明、以及被明确初始化过的全 局变量和静态变量，可以放在数据页的任何地方。
• .switch 它包括为转换声明设置的表格，可以放在程序页也可以放在低地址的数据页。

（2）未被初始化的“SECTIONS”（为程序运行中创建和存放的变量在存储器中保留空间)

• .bss 它为全局变量和静态变量保留空间。在程序开始运行时，C 导入路径把数据从.cinit 节复 制出去然后存在.bss节中，要求放在低地址的数据页；
• .ebss 它是在远(far)访问(只用于 C)和大存储模式下使用，它为全局变量和静态变量保留空间。 在程序开始运行时，C 导入路径把数据从.cinit 段复制出去然后存在.ebss 节中，可以放在数据页的任何地方；
• .stack为C系统堆栈保留空间，这部分存储器为用来将声明传给函数及为局部变量留出空间， 要求放在低地址的数据页；
• .system 动态存储器分配保留空间。这个空间用于 malloc 函数，如果不使用 malloc 函数，这个段的大小就是 0，要求放在低地址的数据页；
• .esystem 动态存储器分配保留空间，这个空间用于外部 malloc 函数，如果不使用外部 malloc函数，这个段的大小就是 0，可以放在数据页的任何地方

Table 5-1 summarizes the initialized sections created under the COFF ABI mode. Table 5-2 summarizes the initialized sections created under the EABI mode. Table 5-3 summarizes the uninitialized sections. Be aware that the COFF ABI .cinit and .pinit (.init_array in EABI) tables have different formats in EABI.

Table 5-1. Initialized Sections Created by the Compiler for COFFABI Name Contents

• .args Command argument for host-based loader; read-only (see the –arg_size option)
• .cinit Tables for explicitly initialized global and static variables
• .const Global and static const variables that are explicitly initialized and contain string literals
• .pinit Table of constructors to be called at startup
• .ppdata Data tables for compiler-based profiling (see the –gen_profileinfo option)
• .ppinfo Correlation tables for compiler-based profiling ( see the –gen_profileinfo option)
• .switch Jump tables for large switch statements
• .text Executable code and constants

  Table 5-2. Initialized Sections Created by the Compiler for EABI

Name Contents

• .args Command argument for host-based loader; read-only (see the –arg_size option)
• .binit Boot time copy tables (See the TMS320C6000 Assembly Language Tools User's Guide for information on BINIT in linker command files.)
• .cinit In EABI mode, the compiler does not generate a .cinit section. However, when the –rom_mode linker option is specified, the linker creates this section, which contains tables for explicitly initialized global and static variables.
• .const Far, const global and static variables, and string constants
• .c6xabi.exidx Index table for exception handling; read-only (see –exceptions option)
• .c6xabi.extab Unwinded instructions for exception handling; read-only (see –exceptions option)
• .fardata Far non-const global and static variables that are explicitly initialized
• .init_array Table of constructors to be called at startup
• .name.load Compressed image of section name; read-only (See the TMS320C6000 Assembly Language Tools User's Guide for information on copy tables.)
• .neardata Near non-const global and static variables that are explicitly initialized
• .ppdata Data tables for compiler-based profiling (see the –gen_profileinfo option)
• .ppinfo Correlation tables for compiler-based profiling (see the –gen_profileinfo option)
• .rodata Global and static variables that have near and const qualifiers
• .switch Jump tables for large switch statements
• .text Executable code and constants

  Table 5-3. Uninitialized Sections Created by the Compiler for Both ABIs

Name Contents

• .bss Global and static variables
• .far Global and static variables declared far
• .stack Stack
• .sysmem Memory for malloc functions (heap)

When you link your program, you must specify where to allocate the sections in memory. In general, initialized sections are linked into ROM or RAM; uninitialized sections are linked into RAM. With the exception of code sections, the initialized and uninitialized sections created by the compiler cannot be allocated into internal program memory

Example 5-2 shows a typical linker command file that links a C program. The command file in this example is named lnk.cmd and lists several linker options:

• –rom_model Tells the linker to use autoinitialization at run time.
• –heap_size Tells the linker to set the C heap size at 0x2000 bytes.
• –stack_size Tells the linker to set the stack size to 0x0100 bytes.
• –library Tells the linker to use an archive library file, rts6200.lib, for input. Example 5-2. Linker Command File

--rom_model
--heap_size=0x2000
--stack_size=0x0100
--library=rts6200.lib
MEMORY
{
VECS: o = 0x00000000 l = 0x000000400 /* reset & interrupt vectors */
PMEM: o = 0x00000400 l = 0x00000FC00 /* intended for initialization */
BMEM: o = 0x80000000 l = 0x000010000 /* .bss, .sysmem, .stack, .cinit */
}
SECTIONS
{
vectors > VECS
.text > PMEM
.data > BMEM
.stack > BMEM
.bss > BMEM
.sysmem > BMEM
.cinit > BMEM
.const > BMEM
.cio > BMEM
.far > BMEM
}